ETO Development Tools 1/ETO Development Tools 1.iso/Tools - Objects/MacApp/MacApp 2.0 CD Release/MacApp 2.0 (Many Libraries)/Libraries/UMacApp.TScroller.p

Text File | 1990-03-27 | 21.2 KB | 849 lines | [TEXT/MPS ]

{$P}
{[a-,body+,h-,o=100,r+,rec+,t=4,u+,#+,j=20/57/1$,n-]}
{ UMacApp.TScroller.p }
{ Copyright © 1987-1990 by Apple Computer Inc.    All rights reserved. }

{--------------------------------------------------------------------------------------------------}
{$S MAOpen}

PROCEDURE TScroller.IScroller(itsSuperView: TView;
                              itsLocation, itsSize: VPoint;
                              itsHSizeDet, itsVSizeDet: SizeDeterminer;
                              itsHorzMax, itsVertMax: VCoordinate;
                              wantHorzSBar, wantVertSBar: BOOLEAN);

    VAR
        scrollLimit:        VPoint;
        itsSuperViewsDocument: TDocument;

    BEGIN
    fScrollBars[h] := NIL;
    fScrollBars[v] := NIL;

    IF itsSuperView <> NIL THEN
        itsSuperViewsDocument := itsSuperView.fDocument
    ELSE
        itsSuperViewsDocument := NIL;

    IView(itsSuperViewsDocument, itsSuperView, itsLocation, itsSize, itsHSizeDet, itsVSizeDet);

    fTranslation := gZeroVPt;
    fMaxTranslation := gZeroVPt;
    fSBarOffsets := gZeroVRect;
    fRespondsToFunctionKeys := TRUE;

    SetScrollParameters(kStdScrollUnit, kStdScrollUnit, FALSE, FALSE);

    scrollLimit.h := itsHorzMax;
    scrollLimit.v := itsVertMax;
    SetScrollLimits(scrollLimit, kDontRedraw);

    IF wantHorzSBar THEN
        CreateScrollBar(h);
    IF wantVertSBar THEN
        CreateScrollBar(v);
    IF wantHorzSBar | wantVertSBar THEN
        AdjustScrollBars(kDontInvalidate);
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAOpen}

PROCEDURE TScroller.IRes(itsDocument: TDocument;
                         itsSuperView: TView;
                         VAR itsParams: Ptr);

    VAR
        scrollLimit:        VPoint;

    BEGIN
    fScrollBars[h] := NIL;
    fScrollBars[v] := NIL;

    INHERITED IRes(itsDocument, itsSuperView, itsParams);

    WITH ScrollerTemplatePtr(itsParams)^ DO
        BEGIN
        fTranslation := gZeroVPt;
        fRespondsToFunctionKeys := TRUE;
        scrollLimit.h := horzMax;
        scrollLimit.v := vertMax;
        SetScrollLimits(scrollLimit, kDontRedraw);

        SetScrollParameters(hScrollUnits, vScrollUnits, hConstrain, vConstrain);
        {$Push} {$H-}
        RectToVRect(sBarOffsets, fSBarOffsets);
        {$Pop}

        IF wantHSBar THEN
            CreateTemplateScrollBar(h);
        IF wantVSBar THEN
            CreateTemplateScrollBar(v);
        IF wantHSBar | wantVSBar THEN
            AdjustScrollBars(kDontInvalidate);
        END;

    OffsetPtr(itsParams, SIZEOF(ScrollerTemplate));
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAWriteRes}

PROCEDURE TScroller.WRes(theResource: ViewRsrcHndl;
                         VAR itsParams: Ptr); OVERRIDE;

    VAR
        scPtr:                ScrollerTemplatePtr;
        aVRect:             VRect;

    BEGIN
    INHERITED WRes(theResource, itsParams);

    scPtr := ScrollerTemplatePtr(ExpandPtr(theResource, itsParams, SIZEOF(ScrollerTemplate)));

    WITH scPtr^ DO
        BEGIN
        wantHSBar := fScrollBars[h] <> NIL;
        wantVSBar := fScrollBars[v] <> NIL;
        vertMax := fScrollLimit.v;
        horzMax := fScrollLimit.h;
        vScrollUnits := fScrollUnit.v;
        hScrollUnits := fScrollUnit.h;
        vConstrain := fConstrain[v];
        hConstrain := fConstrain[h];
        aVRect := fSBarOffsets;
        VRectToRect(aVRect, sBarOffsets);
        END;
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAWriteRes}

PROCEDURE TScroller.WriteRes(theResource: ViewRsrcHndl;
                             VAR itsParams: Ptr); OVERRIDE;

    BEGIN
    gWResSignature := 'scrl'; gWResType := 'TScroller';
    WRes(theResource, itsParams);
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAClose}

PROCEDURE TScroller.Free; OVERRIDE;

    BEGIN
    FreeIfObject(fScrollBars[h]);
    fScrollBars[h] := NIL;

    FreeIfObject(fScrollBars[v]);
    fScrollBars[v] := NIL;

    INHERITED Free;
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAOpen}

PROCEDURE TScroller.AddSubView(theSubView: TView); OVERRIDE;

    BEGIN
    INHERITED AddSubView(theSubView);
    theSubView.BeInScroller(SELF);
    END;

{--------------------------------------------------------------------------------------------------}
{$S MANonRes}

PROCEDURE TScroller.AdjustScrollBars(invalidate: BOOLEAN);

    VAR
        vhs:                VHSelect;
        aScrollBar:         TScrollBar;
        ortho:                VHSelect;
        loc:                VPoint;
        size:                VPoint;

    BEGIN
    FOR vhs := v TO h DO
        BEGIN
        aScrollBar := fScrollBars[vhs];
        IF aScrollBar <> NIL THEN
            BEGIN
            ortho := gOrthogonal[vhs];
            loc := fLocation;
            size := fSize;
            WITH loc DO
                BEGIN
                vh[vhs] := vh[vhs] + fSBarOffsets.topLeft.vh[vhs] - 1;
                vh[ortho] := vh[ortho] + size.vh[ortho];
                END;
            WITH size, fSBarOffsets DO
                BEGIN
                vh[vhs] := vh[vhs] - topLeft.vh[vhs] + botRight.vh[vhs] + 2;
                vh[ortho] := kSBarSize;
                END;

            WITH size DO
                aScrollBar.Resize(h, v, invalidate);
            WITH loc DO
                aScrollBar.Locate(h, v, invalidate);
            END;
        END;
    END;

{--------------------------------------------------------------------------------------------------}
{$S MADoCommand}

PROCEDURE TScroller.AutoScroll(viewPt: VPoint; VAR delta: VPoint);

    VAR
        vhs: VHSelect;
        myExtent: VRect;

    FUNCTION ProportionalScroll(diff: VCoordinate; scrollUnit: Point;
                                maxTranslationchange: VCoordinate; vhs: VHSelect): VCoordinate;

        BEGIN
        IF scrollUnit.vh[vhs] <> 0 THEN
            ProportionalScroll := MinMax(scrollUnit.vh[vhs], IntMultiply((diff +
                                                                         (scrollUnit.vh[vhs] DIV
                                                                         2)) DIV
                                                                         scrollUnit.vh[vhs],
                                                                         scrollUnit.vh[vhs]),
                                         maxTranslationchange)
        ELSE
            ProportionalScroll := scrollUnit.vh[vhs];
        END;

    BEGIN
    delta := gZeroVPt;
    GetExtent(myExtent);
    FOR vhs := v TO h DO
        IF viewPt.vh[vhs] < myExtent.topLeft.vh[vhs] THEN
            delta.vh[vhs] := - ProportionalScroll(myExtent.topLeft.vh[vhs] - viewPt.vh[vhs],
                                                  fScrollUnit, fTranslation.vh[vhs], vhs)
        ELSE IF viewPt.vh[vhs] > myExtent.botRight.vh[vhs] THEN
            delta.vh[vhs] := ProportionalScroll(viewPt.vh[vhs] - myExtent.botRight.vh[vhs],
                                                fScrollUnit, fMaxTranslation.vh[vhs] -
                                                fTranslation.vh[vhs], vhs);
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAOpen}

PROCEDURE TScroller.CreateTemplateScrollBar(itsDirection: VHSelect);

    VAR
        anSScrollBar:        TSScrollBar;
        fi:                 FailInfo;

    PROCEDURE HandleFailure(error: OSErr;
                            message: LONGINT);

        BEGIN
        Free;
        END;

    BEGIN
    CatchFailures(fi, HandleFailure);

    anSScrollBar := TSScrollBar(DoCreateViews(fDocument, fSuperView, kScrollBarId, gZeroVPt));
    anSScrollBar.fDirection := itsDirection;            { !!!Unfortunately this is not part of the
                                                         resource }
    anSScrollBar.fShown := IsShown;                        { Only shows if we show }
    anSScrollBar.AttachScroller(SELF);
    Success(fi);
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAOpen}

PROCEDURE TScroller.CreateScrollBar(itsDirection: VHSelect);

    VAR
        anSScrollBar:        TSScrollBar;
        fi:                 FailInfo;

    PROCEDURE HandleFailure(error: OSErr;
                            message: LONGINT);

        BEGIN
        Free;
        END;

    BEGIN
    CatchFailures(fi, HandleFailure);

    New(anSScrollBar);
    FailNIL(anSScrollBar);
    anSScrollBar.ISScrollBar(fSuperView, gZeroVPt, gZeroVPt, SizeVariable, SizeVariable,
                             itsDirection, fMaxTranslation.vh[itsDirection], SELF);
    Success(fi);
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAScroll}

FUNCTION TScroller.DoKeyCommand(ch: CHAR;
                                aKeyCode: INTEGER;
                                VAR info: EventInfo): TCommand; OVERRIDE;

    PROCEDURE DoPageScroll(partCode: INTEGER);

        VAR
            vDelta:             VCoordinate;

        BEGIN
        vDelta := ScrollStep(v, partCode);
        IF fScrollBars[v] <> NIL THEN
            fScrollBars[v].DeltaValue(vDelta);
        Update;
        END;

    BEGIN
    DoKeyCommand := NIL;
    IF IsViewEnabled & fRespondsToFunctionKeys THEN
        CASE ch OF
            chPageUp:
                DoPageScroll(inPageUp);
            chPageDown:
                DoPageScroll(inPageDown);
            chHome:
                BEGIN
                ScrollTo(0, 0, kRedraw);
                Update;
                END;
            chEnd:
                BEGIN
                ScrollTo(fMaxTranslation.h, fMaxTranslation.v, kRedraw);
                Update;
                END;
            OTHERWISE
                DoKeyCommand := INHERITED DoKeyCommand(ch, aKeyCode, info);
        END
    ELSE
        DoKeyCommand := INHERITED DoKeyCommand(ch, aKeyCode, info);
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAScroll}

PROCEDURE TScroller.DoScroll(delta: VPoint;
                             redraw: BOOLEAN);

    VAR
        vhs:                VHSelect;

    BEGIN
    FOR vhs := v TO h DO
        IF delta.vh[vhs] < 0 THEN
            delta.vh[vhs] := Max(delta.vh[vhs], - fTranslation.vh[vhs])
        ELSE IF delta.vh[vhs] > 0 THEN
            delta.vh[vhs] := Min(delta.vh[vhs], fMaxTranslation.vh[vhs] - fTranslation.vh[vhs]);

    IF NOT EqualVPt(delta, gZeroVPt) THEN
        BEGIN
        {$Push} {$H-}
        AddVPt(delta, fTranslation);
        {$Pop}

        InvalidateFocus;                                { …then keep focus accurate. Remember, since
                                                         focus affects clipping, if fMaxTranslation
                                                         has changed then we may be clipped
                                                         differently. Not just translated
                                                         differently. }

        IF redraw THEN
            ScrollDraw(delta, kInvalidate);                { !!! In the future the decision will
                                                        be made differently as to how to render }
        END;
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAFields}

PROCEDURE TScroller.Fields(PROCEDURE DoToField(fieldName: Str255;
                                               fieldAddr: Ptr;
                                               fieldType: INTEGER)); OVERRIDE;

    BEGIN
    DoToField('TScroller', NIL, bClass);
    DoToField('fTranslation', @fTranslation, bVPoint);
    DoToField('fScrollLimit', @fScrollLimit, bVPoint);
    DoToField('fMaxTranslation', @fMaxTranslation, bVPoint);
    DoToField('fScrollBars[v]', @fScrollBars[v], bObject);
    DoToField('fScrollBars[h]', @fScrollBars[h], bObject);
    DoToField('fScrollUnit', @fScrollUnit, bPoint);
    DoToField('fSBarOffsets', @fSBarOffsets, bVRect);
    DoToField('fConstrain[h]', @fConstrain[h], bBoolean);
    DoToField('fConstrain[v]', @fConstrain[v], bBoolean);
    DoToField('fRespondsToFunctionKeys', @fRespondsToFunctionKeys, bBoolean);
    INHERITED Fields(DoToField);
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAScrollerRes}

FUNCTION TScroller.Focus: BOOLEAN;

    BEGIN
    Focus := INHERITED Focus;
    gLongOffset := fTranslation;

    {$IFC qExperimentalAndUnsupported}
    fFocusRec.LongOffset := fTranslation;
    {$EndC}
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAScrollerRes}

PROCEDURE TScroller.ForceRedraw; OVERRIDE;

    BEGIN
    INHERITED ForceRedraw;
    IF fScrollBars[h] <> NIL THEN
        fScrollBars[h].ForceRedraw;
    IF fScrollBars[v] <> NIL THEN
        fScrollBars[v].ForceRedraw;
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAScrollerRes}

PROCEDURE TScroller.GetExtent(VAR itsExtent: VRect); OVERRIDE;

    BEGIN
    INHERITED GetExtent(itsExtent);
    OffsetVRect(itsExtent, fTranslation.h, fTranslation.v);
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAScrollerRes}

FUNCTION TScroller.GetScroller(immediateSuperView: BOOLEAN): TScroller;

    BEGIN
    GetScroller := SELF;
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAScrollerRes}

PROCEDURE TScroller.HaveScrollBar(theScrollBar: TSScrollBar;
                                  direction: VHSelect);

    BEGIN
    {$IFC qDebug}
    IF (theScrollBar <> NIL) & (theScrollBar.fDirection <> direction) THEN
        ProgramBreak('Scroll bar is wrong direction.');
    {$ENDC}
    fScrollBars[direction] := theScrollBar;
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAScrollerRes}

PROCEDURE TScroller.LocalToSuper(VAR thePoint: VPoint); OVERRIDE;

    VAR
        aVPoint:            VPoint;

    BEGIN
    aVPoint := fTranslation;
    SubVPt(aVPoint, thePoint);
    aVPoint := fLocation;
    AddVPt(aVPoint, thePoint);
    END;

{--------------------------------------------------------------------------------------------------}
{$S MANonRes}

PROCEDURE TScroller.Locate(h, v: VCoordinate;
                           invalidate: BOOLEAN); OVERRIDE;

    BEGIN
    INHERITED Locate(h, v, invalidate);

    AdjustScrollBars(invalidate);
    END;

{--------------------------------------------------------------------------------------------------}
{$S MANonRes}

PROCEDURE TScroller.RemoveSubView(theSubView: TView); OVERRIDE;

    BEGIN
    theSubView.BeInScroller(NIL);
    INHERITED RemoveSubView(theSubView);
    END;

{--------------------------------------------------------------------------------------------------}
{$S MANonRes}

PROCEDURE TScroller.Resize(width, height: VCoordinate;
                           invalidate: BOOLEAN); OVERRIDE;

    VAR
        vhs:                VHSelect;
        sBarWasVisible:     ARRAY [VHSelect] OF BOOLEAN;
        aVPoint:            VPoint;

    BEGIN
 { If the scroll bars are visible, erase them now so that they aren't temporarily
  displayed in the wrong place.}
    FOR vhs := v TO h DO
        IF (fScrollBars[vhs] <> NIL) & fScrollBars[vhs].Focus &
           (fScrollBars[vhs].IsCMgrVisible) THEN
            BEGIN
            sBarWasVisible[vhs] := TRUE;
            IF NOT invalidate THEN
                HideControl(fScrollBars[vhs].fCmgrControl)
            ELSE
                fScrollBars[vhs].SetCMgrVisibility(FALSE);
            END
        ELSE
            sBarWasVisible[vhs] := FALSE;

    INHERITED Resize(width, height, invalidate);
    AdjustScrollBars(invalidate);
    aVPoint := fScrollLimit;
    SetScrollLimits(aVPoint, kDontRedraw);                {Readjust sbar maximums and fMaxTranslation}

    FOR vhs := v TO h DO
        IF sBarWasVisible[vhs] THEN
            fScrollBars[vhs].SetCMgrVisibility(TRUE);
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAScroll}

PROCEDURE TScroller.RevealRect(rectToReveal: VRect;
                               minToSee: Point;
                               redraw: BOOLEAN); OVERRIDE;

    VAR
        myExtent:            VRect;
        vhs:                VHSelect;
        minAmt:             VCoordinate;
        coord:                VCoordinate;
        delta:                VPoint;

    BEGIN
    GetExtent(myExtent);

    FOR vhs := v TO h DO
        BEGIN
        minAmt := Min(LengthVRect(myExtent, vhs), minToSee.vh[vhs]);
        coord := rectToReveal.topLeft.vh[vhs] + minAmt - myExtent.botRight.vh[vhs];
        IF coord <= 0 THEN
            coord := Min(0, rectToReveal.botRight.vh[vhs] - minAmt - myExtent.topLeft.vh[vhs]);
        delta.vh[vhs] := coord;
        END;

    ScrollBy(delta.h, delta.v, redraw);
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAScroll}

PROCEDURE TScroller.ScrollBy(deltaH, deltaV: VCoordinate;
                             redraw: BOOLEAN);

    VAR
        delta:                VPoint;

    BEGIN
    IF (deltaH <> 0) | (deltaV <> 0) THEN
        BEGIN
        IF fScrollBars[v] <> NIL THEN
            fScrollBars[v].DeltaValue(deltaV);
        IF fScrollBars[h] <> NIL THEN
            fScrollBars[h].DeltaValue(deltaH);

        SetVPt(delta, deltaH, deltaV);
        DoScroll(delta, redraw);
        END;
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAScroll}

PROCEDURE TScroller.ScrollDraw(delta: VPoint;
                              invalidate: BOOLEAN);

    VAR
        visRect:            Rect;
        fi:                 FailInfo;
        {$IFC qExperimentalAndUnsupported}
        oldgEnableDoubleBuffering: BOOLEAN;
        {$EndC}

    PROCEDURE HdlScrollDraw(error: OSErr;
                            message: LONGINT);

        BEGIN
        {$IFC qExperimentalAndUnsupported}
        gEnableDoubleBuffering := oldgEnableDoubleBuffering;
        {$ELSEC}
        EndUpdate(thePort);                             { Would be a shame to leave the visRgn
                                                         sclunged }
        {$EndC}
        END;

    PROCEDURE DoScrollDraw;

        VAR
            aPoint: Point;
            aWindow: TWindow;
            theUpdateRgn: RgnHandle;

        BEGIN
        IF (ABS(delta.h) > kMaxCoord) | (ABS(delta.v) > kMaxCoord) THEN { too far to scrollrect }
            InvalidRect(visRect)
        ELSE
            BEGIN
            {$IFC qDebug}
            UseTempRgn('TScroller.ScrollDraw');
            {$ENDC}

            { If we're in a window then remove the update area from the clipRgn since it contains
            stale bits and it's no use to move them (in fact it's damaging) }
            aWindow := GetWindow;
            if aWindow <> NIL THEN
                BEGIN
                theUpdateRgn := WindowPeek(aWindow.fWMgrWindow)^.updateRgn;
                if not EmptyRgn(theUpdateRgn) THEN
                    begin

                    { The update region is in global coords but the clip is in local coords.
                    Offset the region to make it in local coords here and restore it there
                    to save copying it }
                    aPoint := gZeroPt;
                    LocalToGlobal(aPoint);
                    OffsetRgn(theUpdateRgn, -aPoint.h,-aPoint.v);

                    DiffRgn(thePort^.clipRgn, theUpdateRgn, gTempRgn);

                    OffsetRgn(theUpdateRgn, aPoint.h,aPoint.v);

                    SetClip(gTempRgn);
                    END;
                END;

            ScrollRect(visRect, - delta.h, - delta.v, gTempRgn);
            InvalRgn(gTempRgn);

            {$IFC qDebug}
            DoneWithTempRgn;
            {$ENDC}
            END;

        IF qExperimentalAndUnsupported | NOT invalidate THEN
            Update
        ELSE
            InvalidateFocus;
        END;

    BEGIN
    IF Focus THEN
        BEGIN

        GetVisibleRect(visRect);

        IF gIntenseDebugging THEN
            BEGIN
            WrLblRect('                   visRect', visRect);
            WRITELN;
            WrLblVPt('         gLongOffset', gLongOffset);
            WRITELN;
            END;

        IF NOT EmptyRect(visRect) THEN
            BEGIN
            {$IFC qExperimentalAndUnsupported}
            IF gEnableDoubleBuffering & NOT (gPrinting | gDrawingPictScrap) THEN
                BEGIN
                oldgEnableDoubleBuffering := gEnableDoubleBuffering;
                gEnableDoubleBuffering := FALSE;        { so subviews won't attempt to do off screen
                                                         }
                CatchFailures(fi, HdlScrollDraw);
                DoOffScreen(DoScrollDraw);
                Success(fi);
                gEnableDoubleBuffering := oldgEnableDoubleBuffering;
                END
            ELSE
                DoScrollDraw;
            {$ELSEC}
            DoScrollDraw;
            {$EndC}
            END;
        END;
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAScroll}

FUNCTION TScroller.ScrollRelative(vhs: VHSelect;
                                  sBarValue: VCoordinate): VCoordinate;

    VAR
        pixelDelta:         VPoint;
        newValue:            VCoordinate;

    BEGIN
    IF fConstrain[vhs] & (sBarValue <> fMaxTranslation.vh[vhs]) THEN
        newValue := (sBarValue + fScrollUnit.vh[vhs] DIV 2) DIV fScrollUnit.vh[vhs] *
                    fScrollUnit.vh[vhs]
    ELSE
        newValue := sBarValue;

    pixelDelta := gZeroVPt;
    pixelDelta.vh[vhs] := newValue - fTranslation.vh[vhs];
    DoScroll(pixelDelta, kRedraw);
    ScrollRelative := newValue - sBarValue;
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAScroll}

FUNCTION TScroller.ScrollStep(vhs: VHSelect;
                              partCode: INTEGER): VCoordinate;

    VAR
        scrollUnit:         INTEGER;
        delta:                VCoordinate;
        adjustment:         VCoordinate;
        deltaPt:            VPoint;

    BEGIN
    scrollUnit := fScrollUnit.vh[vhs];
    deltaPt := gZeroVPt;
    CASE partCode OF
        inUpButton, inDownButton:
            delta := scrollUnit;
        inPageUp, inPageDown:
            delta := fSize.vh[vhs];
        {$IFC qDebug}
        OTHERWISE
            ProgramBreak(ConcatNumber('TScroller.ScrollStep: bad part code=', partCode));
        {$ENDC}
    END;

    IF (partCode = inUpButton) | (partCode = inPageUp) THEN
        delta := - delta;

    { Constrain if necessary }
    IF fConstrain[vhs] & (scrollUnit <> 0) THEN
        BEGIN
        adjustment := (Max(0, fTranslation.vh[vhs] + delta)) MOD scrollUnit;
        IF adjustment <> 0 THEN
            IF delta > 0 THEN
                delta := delta - adjustment
            ELSE
                delta := delta + (scrollUnit - adjustment)
        END;
    deltaPt.vh[vhs] := delta;

    DoScroll(deltaPt, kRedraw);
    ScrollStep := delta;
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAScroll}

PROCEDURE TScroller.ScrollTo(h, v: VCoordinate;
                             redraw: BOOLEAN);

    BEGIN
    ScrollBy(h - fTranslation.h, v - fTranslation.v, redraw);
    END;

{--------------------------------------------------------------------------------------------------}
{$S MANonRes}

PROCEDURE TScroller.SetScrollLimits(scrollLimit: VPoint;
                                    drawScrollBars: BOOLEAN);

    VAR
        maxCoord:            VCoordinate;
        vhs:                VHSelect;
        newTranslation:     VPoint;

    BEGIN
    fScrollLimit := scrollLimit;
    newTranslation := fTranslation;
    FOR vhs := v TO h DO
        BEGIN
        maxCoord := Max(0, scrollLimit.vh[vhs] - fSize.vh[vhs]);
        IF maxCoord <> fMaxTranslation.vh[vhs] THEN
            BEGIN
            fMaxTranslation.vh[vhs] := maxCoord;
            IF fScrollBars[vhs] <> NIL THEN
                fScrollBars[vhs].SetLongMax(maxCoord, drawScrollBars);

            IF maxCoord < fTranslation.vh[vhs] THEN
                newTranslation.vh[vhs] := maxCoord;
            END;
        END;

    {$Push}{$H-}
    IF NOT EqualVPt(newTranslation, fTranslation) THEN
    {$Pop}
        ScrollTo(newTranslation.h, newTranslation.v, kRedraw);
    END;

{--------------------------------------------------------------------------------------------------}
{$S MANonRes}

PROCEDURE TScroller.SetScrollParameters(horzUnits, vertUnits: VCoordinate;
                                        horzConstraint, vertConstraint: BOOLEAN);

    BEGIN
    fScrollUnit.h := horzUnits;
    fScrollUnit.v := vertUnits;
    fConstrain[h] := horzConstraint;
    fConstrain[v] := vertConstraint;
    END;

{--------------------------------------------------------------------------------------------------}
{$S MANonRes}

PROCEDURE TScroller.SubViewChangedSize(theSubView: TView;
                                       delta: VPoint); OVERRIDE;

    VAR
        aVPoint:            VPoint;

    PROCEDURE DoToSubView(theView: TView);

        BEGIN
        WITH aVPoint, theView DO
            BEGIN
            v := Max(v, fLocation.v + fSize.v);
            h := Max(h, fLocation.h + fSize.h);
            END;
        END;

    BEGIN
    aVPoint := gZeroVPt;
    EachSubView(DoToSubView);
    SetScrollLimits(aVPoint, kRedraw);
    END;

{--------------------------------------------------------------------------------------------------}
{$S MAScrollerRes}

PROCEDURE TScroller.SuperToLocal(VAR thePoint: VPoint); OVERRIDE;

    VAR
        aVPoint:            VPoint;

    BEGIN
    aVPoint := fLocation;
    SubVPt(aVPoint, thePoint);
    aVPoint := fTranslation;
    AddVPt(aVPoint, thePoint);
    END;